home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 7: Sunsite / Linux Cubed Series 7 - Sunsite Vol 1.iso / system / filesyst / thsfs.tgz / thsfs.tar / thsfs / kompr1.c < prev    next >
C/C++ Source or Header  |  1994-10-04  |  4KB  |  261 lines
  1. /*************************************************************
  2.  *                                                           *
  3.  *    ths  Filesystem                  04.10.94      V1.1    *
  4.  *                                                           *
  5.  *    Thomas Scheuermann     ths@ai-lab.fh-furtwangen.de     *
  6.  *                                                           *
  7.  *************************************************************/
  8.  
  9. #include <linux/kernel.h>
  10. #include <linux/module.h>
  11. #include <linux/sched.h>
  12. #include <linux/errno.h>
  13. #include <linux/string.h>
  14. #include <linux/stat.h>
  15. #include <linux/mm.h>
  16. #include <linux/locks.h>
  17. #include <linux/fs.h>
  18. #include <linux/malloc.h>
  19.  
  20. #include <asm/system.h>
  21. #include <asm/segment.h>
  22. #include <asm/bitops.h>
  23.  
  24. #include "ths.h"
  25. #include "ths_i.h"
  26.  
  27. /*
  28.  * Dekompressionsalgorithmus
  29.  * funktioniert nur mit Komprimierung 2
  30.  */
  31.  
  32. void decompress(struct super_block *s, struct ths_buffer *tbf, int mdfat)
  33. {
  34.     unsigned char zc,zu,flag,*data=NULL;
  35.     unsigned long sektor;
  36.     struct buffer_head *bh;
  37.     int i,k,rb,rl,hz,m,sek,sekmax;
  38.  
  39. #ifdef DEBUG
  40.     printk("decompress %d\n",mdfat);
  41. #endif
  42.  
  43.     sektor = (mdfat & 0x1fffff) +1;
  44.     sekmax = ((mdfat & 0x3c000000)>>26) +1;
  45.  
  46. /*
  47.  * i    : Bitzaehler
  48.  * k    : Zeichenzaehler dekomprimiert
  49.  * hz    : Hilfszaehler fuer Bits;
  50.  * rb    : Rueckwaertsbezug rb Bytes
  51.  * rl    : Laenge des Rueckwaertsbezugs
  52.  * m    : Laengenhilfsspeicher
  53.  * flag    : Status
  54.  * zc    : komprimiertes Zeichen
  55.  * zu    : unkomprimiertes Zeichen
  56.  * sek    : Sektorzaehler
  57.  */
  58.     k=0;
  59.     zu=0;
  60.     zc=0;
  61.     rb=0;
  62.     rl=0;
  63.     hz=0;
  64.     m=0;
  65.     sek = 0;
  66.     flag = 'n';
  67.  
  68.     for(i=0;sek<sekmax;)
  69.     {
  70.         if(!(i%8))
  71.         {
  72.             if(!(i%4096))
  73.             {
  74.                 data = ths_uread(s,sektor+i/4096,&bh);
  75.             }
  76.             if(!i)
  77.             {
  78.                 if(data[0]!=0x44 && data[1]!=0x53 && data[2]!=0x00 && data[3]!=0x02)
  79.                 {
  80.                     printk("Komprimierung nicht erkannt!!\n");
  81.                     return;
  82.                 }
  83.                 i=32;
  84.             }
  85.             zc = data[(i/8)%512];
  86.         }
  87.         switch(flag)
  88.         {
  89.             case 'n':        /* neu */
  90.                 if(zc&1)
  91.                     flag = 'I';
  92.                 else
  93.                     flag = 'O';
  94.                 zc >>= 1;
  95.                 break;
  96.             case 'I':        /* erstes Bit 1 */
  97.                 if(zc&1)
  98.                     flag = 'r';
  99.                 else
  100.                 {
  101.                     flag = 'L';
  102.                     hz = 7;
  103.                 }
  104.                 zc >>= 1;
  105.                 break;
  106.             case 'O':        /* erstes Bit 0 */
  107.                 if(zc&1)
  108.                 {
  109.                     flag = 'l';
  110.                     hz=7;
  111.                 }
  112.                 else
  113.                 {
  114.                     flag = 'A';
  115.                     hz = 6;
  116.                     rb = 0;
  117.                 }
  118.                 zc >>= 1;
  119.                 break;
  120.             case 'l':        /* Zeichen 0 - 127 */
  121.                 if(zc&1)
  122.                     zu |=0x80;
  123.                 zu >>= 1;
  124.                 zc >>= 1;
  125.                 if(!(--hz))
  126.                 {
  127.                     flag ='n';
  128.                     (tbf->data[k/512])[k%512] = zu;
  129.                     k++;
  130.                     zu=0;
  131.                 }
  132.                 break;
  133.             case 'L':        /* Zeichen 128 - 255 */
  134.                 if(zc&1)
  135.                     zu |=0x80;
  136.                 zu >>= 1;
  137.                 zc >>= 1;
  138.                 if(!(--hz))
  139.                 {
  140.                     zu |=0x80;
  141.                     flag ='n';
  142.                     (tbf->data[k/512])[k%512] = zu;
  143.                     k++;
  144.                     zu=0;
  145.                 }
  146.                 break;
  147.             case 'r':        /* Rueck ? */
  148.                 if(zc&1)
  149.                 {
  150.                     flag = 'C';
  151.                     hz = 12;
  152.                     rb = 0;
  153.                 }
  154.                 else
  155.                 {
  156.                     flag = 'B';
  157.                     hz = 8;
  158.                     rb = 0;
  159.                 }
  160.                 zc >>= 1;
  161.                 break;
  162.             case 'A':        /* 6 Bit rueckwarts */
  163.                 if(zc&1)
  164.                     rb |=0x40;
  165.                 rb >>= 1;
  166.                 zc >>= 1;
  167.                 if(!(--hz))
  168.                 {
  169.                     flag ='X';
  170.                 }
  171.                 break;
  172.             case 'B':        /* 8 Bit rueckwarts */
  173.                 if(zc&1)
  174.                     rb |=0x100;
  175.                 rb >>= 1;
  176.                 zc >>= 1;
  177.                 if(!(--hz))
  178.                 {
  179.                     flag ='X';
  180.                     rb += 64;
  181.                 }
  182.                 break;
  183.             case 'C':        /* 12 Bit rueckwarts */
  184.                 if(zc&1)
  185.                     rb |=0x1000;
  186.                 rb >>= 1;
  187.                 zc >>= 1;
  188.                 if(!(--hz))
  189.                 {
  190.                     if(rb==0xfff)
  191.                     {
  192.                         sek++;
  193.                         flag = 'n';
  194.                         break;
  195.                     }
  196.                     flag ='X';
  197.                     rb +=320;
  198.                 }
  199.                 break;
  200.             case 'X':        /* Trefferlaenge, 0 zaehlen */
  201.                 if(zc&1)
  202.                 {
  203.                     flag = 'Y';
  204.                     rl =0;
  205.                     m = 1;
  206.                     m <<=hz;
  207.                     if(m==1)
  208.                     {
  209.                         flag = 'n';
  210.                         (tbf->data[k/512])[k%512] = (tbf->data[(k-rb)/512])[(k-rb)%512];
  211.                         k++;
  212.                         (tbf->data[k/512])[k%512] = (tbf->data[(k-rb)/512])[(k-rb)%512];
  213.                         k++;
  214.                     }
  215.                 }
  216.                 else
  217.                 {
  218.                     hz++;
  219.                 }
  220.                 zc >>= 1;
  221.                 break;
  222.             case 'Y':        /* Trefferlaenge berechnen */
  223.                 if(!(--hz))
  224.                 {
  225.                     if(zc&1)
  226.                         rl |= m;
  227.                     rl >>= 1;
  228.                     rl = rl + m + 1;
  229.                     for(hz=0;hz<rl;hz++)
  230.                     {
  231.                         (tbf->data[k/512])[k%512] = (tbf->data[(k-rb)/512])[(k-rb)%512];
  232.                         k++;
  233.                     }
  234.                     flag = 'n';
  235.                 }
  236.                 else
  237.                 {
  238.                     if(zc&1)
  239.                         rl |= m;
  240.                     rl >>= 1;
  241.                 }
  242.                 zc >>= 1;
  243.                 break;
  244.         }
  245.         i++;
  246.         if(!(i%4096))
  247.         {
  248.             brelse(bh);
  249.         }
  250.     }
  251.     if((i%4096))
  252.     {
  253.         brelse(bh);
  254.     }
  255.     return;
  256. }
  257.  
  258.  
  259.  
  260.  
  261.